
// #include <typeinfo>
// #include <utility>
// #include <iostream>
// #include <cassert>
// #include <any>

// //想要实现, 这个功能 Any 可以给任何一个类型的数据

// // class Any{
// // private:
// //     class holder{
// //     public:
// //         virtual ~holder(){}
// //         virtual holder* clone() = 0;
// //         virtual const std::type_info& type() = 0;
// //     };

// //     template<class T> 
// //     class placeholder:public holder{
        
// //     public:
// //         T _val;
// //         placeholder(const T & val ):_val(val){ }
// //         holder* clone() {
// //             return new placeholder<T>(_val);
// //         }
// //         const std::type_info& type(){
// //             return typeid(T);
// //         }
// //     };
// // private:
// //     Any& swap(Any& other){
// //         std::swap(other._content, _content);
// //         return *this;
// //     }
// //     holder* _content;
// // public:
// //     Any():_content(nullptr){}
// //     Any(const Any& other) : _content(other._content ? (other._content)->clone() : nullptr) { }
// //     template<class T>
// //     Any(const T& val) : _content(new placeholder<T>(val)) { }
// //     Any& operator=(Any other){
// //         /*这⾥要注意形参只是⼀个临时对象，进⾏交换后就会释放，所以交换后，原先保存的placeholder指针也会被销毁*/
// //         other.swap(*this);
// //         return *this;
// //     }
// //     template<class T> 
// //     Any& operator=(const T& val){
// //         /*为val构建⼀个临时对象出来，然后进⾏交换，这样临时对象销毁的时候，顺带原先保存的placeholder也会被销毁*/
// //         Any(val).swap(*this);
// //         return *this;
// //     }
// //     ~Any(){ if(_content) delete _content; }

// //     const std::type_info& type(){
// //         return (_content)->type();
// //     }

// //     template<class T>
// //     T* get(){

// //         //想要获取的数据类型必须和保存的数据类型一致;
// //         assert(typeid(T) == _content->type());
// //         return &((placeholder<T>*)_content)->_val;
// //     }

// // };
// #include <vector>


// int main(){

//     std::cout << std::boolalpha;
 
//     // any 类型
//     std::any a = 1;
//     std::cout << a.type().name() << ": " << std::any_cast<int>(a) << '\n';
//     a = 3.14;
//     std::cout << a.type().name() << ": " << std::any_cast<double>(a) << '\n';
//     a = true;
//     std::cout << a.type().name() << ": " << std::any_cast<bool>(a) << '\n';
//     a = "sdasasd";
//     std::cout << a.type().name() << ": " << std::any_cast<const char*>(a) << '\n';

//     std::vector<int> arr  = {1,2,1,5,8,45,234,76};
//     // std::cout << a.type().name() << ": " << std::any_cast<const char*>(a) << '\n';
//     return 0;
// }

#include <iostream>
using namespace std;
#include <vector>
// 1. 扩容之后，迭代器已经失效了，程序虽然可以运行，但是运行结果已经不对了
int main()
{
	vector<int> v{ 1,2,3,4,5 };

	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;

	auto it = v.begin();
	cout << "扩容之前，vector的容量为: " << v.capacity() << endl;

	// 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效 
	v.reserve(100);
	cout << "扩容之后，vector的容量为: " << v.capacity() << endl;

	// 经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会
	// 虽然可能运行，但是输出的结果是不对的

	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}